# 创建结点类
class Node:
    def __init__(self, val, next_node=None):
        """
        链表结点类
        :param val: 为结点的数据
        :param next_node: obj类型，指向下一个结点
        """
        self.val = val  # 有用数据
        self.next = next_node


# 链表的操作
class LinkList:
    def __init__(self):
        self.head = None
        self.length = 0

    def init_list(self, target):
        """
        初始化链表函数
        :param target: list类型，链表每一个元素的数据
        :return: Node类型，返回头结点
        """
        self.head = Node(None)  # 链表的开头
        p = self.head  # 可移动变量p（指针）
        for item in target:
            p.next = Node(item)
            p = p.next
            self.length += 1
        return self.head

    def show(self):
        """
        显示函数，显示链表的所有元素
        :return:
        """
        p = self.head.next
        while p:
            print(p.val, end=" ")
            p = p.next
        print()

    def append(self, value):
        """
        添加方法，向链表的最后位置添加一个元素
        :param value: 待添加的元素
        :return:
        """
        p = self.head
        while True:
            if p.next == None:
                p.next = Node(value)
                break
            p = p.next

    def remove(self, value):
        """
        移除链式中的数据
        :param value: 待移除的数据的值
        :return:
        """
        p = self.head.next
        q = None  # 用于记录带移除的数据的前一个数据的地址
        while p:
            if p.val == value:
                q.next = p.next
                del p
                break
            q = p
            p = p.next

    def add(self, pos, value):
        """
        向链表中间添加一个元素
        :param pos: int类型，待添加的位置的信息
        :param value: 添加的数据
        :return:
        """
        if isinstance(pos, int):
            raise TypeError("需要int类型参数")
        elif pos > self.length:
            self.append(value)
        elif pos < 0:
            pos = 0
        p = self.head
        q = None
        count = 0
        while p:
            if count == pos:
                q = p.next
                m = Node(value)
                p.next = m
                m.next = q
            count += 1
            p = p.next

    def clear(self):
        """
        删除整个链表
        :return:
        """
        self.head.next = None

    def get_elm(self, pos):
        if isinstance(pos, int):
            raise TypeError("需要int类型")
        elif pos < 0 or pos > self.length:
            raise IndexError("超出范围")
        count = 0
        while p:
            if count == pos:
                print(p.val)
            count += 1
            p = p.next

    def get_length(self):
        """
        获取链表长度
        :return: int类型，返回长度
        """
        self.length = -1
        p = self.head
        while p:
            p = p.next
            self.length += 1
        return self.length

    def is_empty(self):
        """
        判断链表是否为空
        :return: bool类型，空则返回Ture，反之False
        """
        if self.head.next is None:
            return True
        else:
            return False

    def remove_pos(self, pos):
        """
        删除链表指定位置的数据
        :param pos: int类型，指定位置
        :return: bool类型，False删除失败，True删除成功
        """
        p = self.head
        if self.is_empty():
            return False
        self.get_length()
        for i in range(self.length):
            p = p.next
        else:
            p.next = p.next.next
            return True
